home *** CD-ROM | disk | FTP | other *** search
/ Day Cry / Day Cry CD.bin / oh_towns / tetujin / src.lzh / G_EFF / FUZZY.C < prev    next >
Text File  |  1994-06-05  |  25KB  |  1,291 lines
  1. /*
  2.         graphic effect lib.
  3.           Fazzy Legato
  4.  
  5.         h. Toda 1994 2 6
  6. */
  7.  
  8. #include <stdio.h>
  9. #include <stdlib.h>
  10. #include <egb.h>
  11. #include "g_eff.h"
  12.  
  13. #define NOERR 0        /* no error */
  14.  
  15. static int mx ;
  16. static int aSen ;
  17. static int mSen ;
  18. static int cMax ;
  19. static int aMax ;
  20. static int x1 ;
  21. static int y1 ;
  22. static int x2 ;
  23. static int y2 ;
  24. static int (*read1)() ;
  25. static int (*read2)() ;
  26. static int (*write)() ;
  27. static int (*mask)() ;
  28.  
  29. static int md ;
  30. static int fSen ;
  31.  
  32. g_fuzzyLegato( BASICPARA *para, int mode, int fuzzySen )
  33. {
  34.     mx = para->mix ;
  35.     aSen = para->alphaSen ;
  36.     mSen = para->maskSen ;
  37.     cMax = para->colorMax ;
  38.     aMax = para->alphaMax ;
  39.     x1 = para->lupx ;
  40.     y1 = para->lupy ;
  41.     x2 = para->rdwx ;
  42.     y2 = para->rdwy ;
  43.     read1 = para->read1 ;
  44.     read2 = para->read2 ;
  45.     write = para->write ;
  46.     mask = para->mask ;
  47.  
  48.     md = mode ;
  49.     fSen = fuzzySen ;
  50.  
  51.     switch( md )
  52.     {
  53.     case 0:
  54.     case 1:
  55.         smooth() ;
  56.         break ;
  57.     case 2:
  58.         smooth_a() ;
  59.         break ;
  60.     case 3:
  61.         smooth_a() ;
  62.         smooth() ;
  63.         break ;
  64.     default:
  65.         smooth() ;
  66.         break ;
  67.     }
  68.  
  69.     return NOERR ;
  70. }
  71.  
  72.  
  73. /* RGB data Åêù¥ */
  74.  
  75. static smooth()
  76. {
  77.     unsigned char a[4], b[4], c[4], d[4] ;
  78.     int cmp, start, mid, fine, mode, s, x, y ;
  79.     int k0, k1, k2 ;
  80.     int smid ;
  81.  
  82.     s = ( 256*(cMax+1) - fSen*(cMax+1) ) / 256 ;        /* sharp rate */
  83.     smid = cMax * 96 / 256 ;
  84.  
  85.     for( y=y1+1 ; y<=y2-1 ; y++ )    /* î┤ëµé╠ô]æù */
  86.     {
  87.         for( x=x1+1 ; x<=x2-1 ; x++ )
  88.         {
  89.             if( (mSen == 0) || (mask( x, y ) < mSen) )
  90.             {
  91.                 read1( x, y, a ) ;
  92.                 read2( x, y, b ) ;
  93.                 a[3] = b[3] ;
  94.                 if( aSen )
  95.                 {
  96.                     if( b[3] )
  97.                     {
  98.                         write( x, y, a ) ;
  99.                     }
  100.                 }
  101.                 else
  102.                 {
  103.                     write( x, y, a ) ;
  104.                 }
  105.             }
  106.         }
  107.     }
  108.  
  109.     for( y=y1+1 ; y<=y2-1 ; y++ )
  110.     {
  111.         mode = 0;
  112.         for( x=x1+1 ; x<=x2-1 ; x++ )
  113.         {
  114.             read1( x,   y,   a ) ;
  115.             read1( x,   y+1, b ) ;
  116.             read1( x+1, y,   c ) ;
  117.             read1( x+1, y-1, d ) ;
  118.             cmp = cmpdata( a, b, s );
  119.             if( (mode == 0) && cmp )
  120.             {
  121.                 mode = 1;
  122.                 start = x;
  123.                 k0 = 0;
  124.             }
  125.             if( (mode == 1) && (cmp == 0) )
  126.                 mode = 0;
  127.             if( (mode == 2) && (cmpdata( a, d, s ) == 0) )
  128.             {
  129.                 mode = 0;
  130.                 fine = x;
  131.                 smooth1( start, mid, fine, y );
  132.                 x = mid;
  133.             }
  134.             if( mode == 1 )
  135.             {
  136.               k1 = katamuki( x, y );
  137.               if( cmpdata(a,c,s) )
  138.               {
  139.                 if( (k1 <= k0) && (k1 < 0) )
  140.                 {
  141.                   k2 = katamuki( x+1, y );
  142.                   if( (k1 <= k2) || (cmpdata(b,c,smid) == 0) )
  143.                   {
  144.                     mode = 2;
  145.                     mid = x;
  146.                   }
  147.                 }
  148.               }
  149.               k0 = k1;
  150.  
  151.               if( x == x2-1 )        /* ì┼îπé╠ùßèOÅêù¥ 1994 2 8 é╔Æ╟ë┴ */
  152.               {
  153.                   mode = 2 ;
  154.                   mid = x ;
  155.               }
  156.  
  157.             }
  158. //            if( (mode == 2) && (cmpdata( c, d, s ) == 0) )
  159.             if( (mode == 2) && ( (cmpdata( c, d, s ) == 0) || (x == x2-1) ) )
  160.             {                                  /* ì┼îπé╠ùßèOÅêù¥ü¬ */
  161.                 mode = 0;
  162.                 fine = x;
  163.                 smooth1( start, mid, fine, y );
  164.                 x = mid;
  165.             }
  166.         }
  167.     }
  168.  
  169.     for( y=y1+1 ; y<=y2-1 ; y++ )
  170.     {
  171.         mode = 0;
  172.         for( x=x2-1 ; x>=x1+1 ; x-- )
  173.         {
  174.             read1( x,   y,   a ) ;
  175.             read1( x,   y+1, b ) ;
  176.             read1( x-1, y,   c ) ;
  177.             read1( x-1, y-1, d ) ;
  178.             cmp = cmpdata( a, b, s );
  179.             if( (mode == 0) && cmp )
  180.             {
  181.                 mode = 1;
  182.                 start = x;
  183.                 k0 = 0;
  184.             }
  185.             if( (mode == 1) && (cmp == 0) )
  186.                 mode = 0;
  187.             if( (mode == 2) && (cmpdata( a, d, s ) == 0) )
  188.             {
  189.                 mode = 0;
  190.                 fine = x;
  191.                 smooth2( start, mid, fine, y );
  192.                 x = mid;
  193.             }
  194.             if( mode == 1 )
  195.             {
  196.               k1 = katamuki( x, y );
  197.               if( cmpdata(a,c,s) )
  198.               {
  199.                 if( (k1 >= k0) && (k1 > 0) )
  200.                 {
  201.                   k2 = katamuki( x-1, y );
  202.                   if( (k1 >= k2) || (cmpdata(b,c,smid) == 0) )
  203.                   {
  204.                     mode = 2;
  205.                     mid = x;
  206.                   }
  207.                 }
  208.               }
  209.               k0 = k1;
  210.  
  211.               if( x == x1+1 )        /* ì┼îπé╠ùßèOÅêù¥ */
  212.               {
  213.                   mode = 2 ;
  214.                   mid = x ;
  215.               }
  216.  
  217.             }
  218. //            if( (mode == 2) && (cmpdata( c, d, s ) == 0) )
  219.             if( (mode == 2) && ( (cmpdata( c, d, s ) == 0) || (x == x1+1) ) )
  220.             {                                  /* ì┼îπé╠ùßèOÅêù¥ü¬ */
  221.                 mode = 0;
  222.                 fine = x;
  223.                 smooth2( start, mid, fine, y );
  224.                 x = mid;
  225.             }
  226.         }
  227.     }
  228.  
  229.     for( x=x1+1 ; x<=x2-1 ; x++ )
  230.     {
  231.         mode = 0;
  232.         for( y=y1+1 ; y<=y2-1 ; y++ )
  233.         {
  234.             read1( x,   y,   a ) ;
  235.             read1( x+1, y,   b ) ;
  236.             read1( x,   y+1, c ) ;
  237.             read1( x-1, y+1, d ) ;
  238.             cmp = cmpdata( a, b, s );
  239.             if( (mode == 0) && cmp )
  240.             {
  241.                 mode = 1;
  242.                 start = y;
  243.                 k0 = 0;
  244.             }
  245.             if( (mode == 1) && (cmp == 0) )
  246.                 mode = 0;
  247.             if( (mode == 2) && (cmpdata( a, d, s ) == 0) )
  248.             {
  249.                 mode = 0;
  250.                 fine = y;
  251.                 smooth3( start, mid, fine, x );
  252.                 y = mid;
  253.             }
  254.             if( mode == 1 )
  255.             {
  256.               k1 = katamuki( x, y );
  257.               if( cmpdata(a,c,s) )
  258.               {
  259.                 if( (k1 <= k0) && (k1 < 0) )
  260.                 {
  261.                   k2 = katamuki( x, y+1 );
  262.                   if( (k1 <= k2) || (cmpdata(b,c,smid) == 0) )
  263.                   {
  264.                     mode = 2;
  265.                     mid = y;
  266.                   }
  267.                 }
  268.               }
  269.               k0 = k1;
  270.  
  271.               if( y == y2-1 )        /* ì┼îπé╠ùßèOÅêù¥ */
  272.               {
  273.                   mode = 2 ;
  274.                   mid = y ;
  275.               }
  276.  
  277.             }
  278. //            if( (mode == 2) && (cmpdata( c, d, s ) == 0) )
  279.             if( (mode == 2) && ( (cmpdata( c, d, s ) == 0) || (y == y2-1) ) )
  280.             {                                  /* ì┼îπé╠ùßèOÅêù¥ü¬ */
  281.                 mode = 0;
  282.                 fine = y;
  283.                 smooth3( start, mid, fine, x );
  284.                 y = mid;
  285.             }
  286.         }
  287.     }
  288.  
  289.     for( x=x2-1 ; x>=x1+1 ; x-- )
  290.     {
  291.         mode = 0;
  292.         for( y=y1+1 ; y<=y2-1 ; y++ )
  293.         {
  294.             read1( x,   y,   a ) ;
  295.             read1( x-1, y,   b ) ;
  296.             read1( x,   y+1, c ) ;
  297.             read1( x+1, y+1, d ) ;
  298.             cmp = cmpdata( a, b, s );
  299.             if( (mode == 0) && cmp )
  300.             {
  301.                 mode = 1;
  302.                 start = y;
  303.                 k0 = 0;
  304.             }
  305.             if( (mode == 1) && (cmp == 0) )
  306.                 mode = 0;
  307.             if( (mode == 2) && (cmpdata( a, d, s ) == 0) )
  308.             {
  309.                 mode = 0;
  310.                 fine = y;
  311.                 smooth4( start, mid, fine, x );
  312.                 y = mid;
  313.             }
  314.             if( mode == 1 )
  315.             {
  316.               k1 = katamuki( x, y );
  317.               if( cmpdata(a,c,s) )
  318.               {
  319.                 if( (k1 >= k0) && (k1 > 0) )
  320.                 {
  321.                   k2 = katamuki( x, y+1 );
  322.                   if( (k1 >= k2) || (cmpdata(b,c,smid) == 0) )
  323.                   {
  324.                     mode = 2;
  325.                     mid = y;
  326.                   }
  327.                 }
  328.               }
  329.               k0 = k1;
  330.  
  331.               if( y == y2-1 )        /* ì┼îπé╠ùßèOÅêù¥ */
  332.               {
  333.                   mode = 2 ;
  334.                   mid = y ;
  335.               }
  336.  
  337.             }
  338. //            if( (mode == 2) && (cmpdata( c, d, s ) == 0) )
  339.             if( (mode == 2) && ( (cmpdata( c, d, s ) == 0) || (y == y2-1) ) )
  340.             {                                  /* ì┼îπé╠ùßèOÅêù¥ü¬ */
  341.                 mode = 0;
  342.                 fine = y;
  343.                 smooth4( start, mid, fine, x );
  344.                 y = mid;
  345.             }
  346.         }
  347.     }
  348.     return NOERR;
  349. }
  350.  
  351. static katamuki( x, y )        /* return=(katamuki + or 0 or -) s=rate */
  352. int x, y;
  353. {
  354.     unsigned char p[3][3][4];
  355.     int ck;
  356.  
  357.     ck = 0;
  358.  
  359.     if( (x <= 0) || (y <= 0) )
  360.         return 0 ;
  361.  
  362.     read1( x-1, y-1, p[0][0] ) ;
  363.     read1( x,   y-1, p[0][1] ) ;
  364.     read1( x+1, y-1, p[0][2] ) ;
  365.     read1( x-1, y,   p[1][0] ) ;
  366.     read1( x,   y,   p[1][1] ) ;
  367.     read1( x+1, y,   p[1][2] ) ;
  368.     read1( x-1, y+1, p[2][0] ) ;
  369.     read1( x,   y+1, p[2][1] ) ;
  370.     read1( x+1, y+1, p[2][2] ) ;
  371.     ck = ck - kata_s( p[0][0], p[1][1] );
  372.     ck = ck - kata_s( p[0][1], p[1][2] );
  373.     ck = ck - kata_s( p[1][0], p[2][1] );
  374.     ck = ck - kata_s( p[1][1], p[2][2] );
  375.  
  376.     ck = ck + kata_s( p[0][1], p[1][0] );
  377.     ck = ck + kata_s( p[0][2], p[1][1] );
  378.     ck = ck + kata_s( p[1][1], p[2][0] );
  379.     ck = ck + kata_s( p[1][2], p[2][1] );
  380.  
  381.     return ck;
  382. }
  383.  
  384. static kata_s( a, b )        /* total abs(sub) */
  385. unsigned char *a, *b;
  386. {
  387.     int subd, add;
  388.  
  389.     subd = (int)b[0] - (int)a[0] ;
  390.     if( subd < 0 )subd = -subd ;
  391.     add = subd ;
  392.     subd = (int)b[1] - (int)a[1] ;
  393.     if( subd < 0 )subd = -subd ;
  394.     add = add + subd ;
  395.     subd = (int)b[2] - (int)a[2] ;
  396.     if( subd < 0 )subd = -subd ;
  397.     add = add + subd ;
  398.     return add;
  399. }
  400.  
  401. static cmpdata( a, b, rate )
  402. unsigned char *a, *b;
  403. int rate;
  404. {
  405.     int subd;
  406.  
  407.     subd = (int)b[0] - (int)a[0] ;
  408.     if( subd < 0 )subd = -subd ;
  409.     if( subd > rate )return 1;
  410.     subd = (int)b[1] - (int)a[1] ;
  411.     if( subd < 0 )subd = -subd ;
  412.     if( subd > rate )return 1;
  413.     subd = (int)b[2] - (int)a[2] ;
  414.     if( subd < 0 )subd = -subd ;
  415.     if( subd > rate )return 1;
  416.     return 0 ;
  417. }
  418.  
  419. static smooth1( st, md, fn, y )
  420. int st, md, fn, y;
  421. {
  422.     int x1, x2, x3;
  423.     int i, n, rate;
  424.     unsigned char a[4], b[4], c[4], d[4] ;
  425.  
  426.     x1 = ( st + md ) >> 1;